home *** CD-ROM | disk | FTP | other *** search
/ PC World 2007 June / PCWorld_2007-06_cd.bin / v cisle / tclock / tclocklight-040702-3.exe / source / common / reg.c < prev    next >
Encoding:
C/C++ Source or Header  |  2004-05-09  |  7.5 KB  |  391 lines
  1. /*-------------------------------------------------------------
  2.   reg.c : read/write settings from/to ini file/registry
  3.   (C) 1997-2003 Kazuto Sato
  4.   Please read readme.txt about the license.
  5.   
  6.   Written by Kazubon, Nanashi-san
  7. ---------------------------------------------------------------*/
  8.  
  9. #include "common.h"
  10.  
  11. extern BOOL g_bIniSetting;
  12. extern char g_inifile[];
  13.  
  14. // registry key
  15. static char *m_mykey = REGMYKEY;
  16.  
  17. /*------------------------------------------------
  18.   get a string from TClock setting
  19. --------------------------------------------------*/
  20. int GetMyRegStr(const char *section, const char *entry,
  21.     char *val, int cbData, const char *defval)
  22. {
  23.     char key[80];
  24.     HKEY hkey;
  25.     DWORD regtype;
  26.     DWORD size;
  27.     BOOL b;
  28.     int r;
  29.     
  30.     if(g_bIniSetting) key[0] = 0;
  31.     else strcpy(key, m_mykey);
  32.     
  33.     if(section && *section)
  34.     {
  35.         if(!g_bIniSetting) strcat(key, "\\");
  36.         strcat(key, section);
  37.     }
  38.     else
  39.     {
  40.         if(g_bIniSetting) strcpy(key, "Main");
  41.     }
  42.     
  43.     if(g_bIniSetting)
  44.     {
  45.         r = GetPrivateProfileString(key, entry, defval, val,
  46.             cbData, g_inifile);
  47.     }
  48.     else
  49.     {
  50.         b = FALSE;
  51.         if(RegOpenKey(HKEY_CURRENT_USER, key, &hkey) == 0)
  52.         {
  53.             size = cbData;
  54.             if(RegQueryValueEx(hkey, entry, 0, ®type,
  55.                 (LPBYTE)val, &size) == 0)
  56.             {
  57.                 if(size == 0) *val = 0;
  58.                 r = size;
  59.                 b = TRUE;
  60.             }
  61.             RegCloseKey(hkey);
  62.         }
  63.         if(b == FALSE)
  64.         {
  65.             strcpy(val, defval);
  66.             r = strlen(defval);
  67.         }
  68.     }
  69.     
  70.     return r;
  71. }
  72.  
  73. /*------------------------------------------------
  74.   get a wide-string from TClock setting
  75. --------------------------------------------------*/
  76. int GetMyRegStrW(const char *section, const char *entry,
  77.     wchar_t *dst, int cbData, const char *defval)
  78. {
  79.     char* buf;
  80.     int r;
  81.     
  82.     buf = malloc(cbData+1);
  83.     
  84.     r = GetMyRegStr(section, entry, buf, cbData, defval);
  85.     
  86.     if(r > 0)
  87.         r = MultiByteToWideChar(CP_ACP, 0, buf, -1, dst, cbData);
  88.     else dst[0] = 0;
  89.     
  90.     free(buf);
  91.     
  92.     return r;
  93. }
  94.  
  95. /*-------------------------------------------
  96.   write a string to TClock setting
  97. ---------------------------------------------*/
  98. BOOL SetMyRegStr(const char *section, const char *entry, const char *val)
  99. {
  100.     HKEY hkey;
  101.     BOOL r;
  102.     char key[80];
  103.     
  104.     if(g_bIniSetting) key[0] = 0;
  105.     else strcpy(key, m_mykey);
  106.     
  107.     if(section && *section)
  108.     {
  109.         if(!g_bIniSetting) strcat(key, "\\");
  110.         strcat(key, section);
  111.     }
  112.     else
  113.     {
  114.         if(g_bIniSetting) strcpy(key, "Main");
  115.     }
  116.     
  117.     if(g_bIniSetting)
  118.     {
  119.         const char *p;
  120.         BOOL b_chkflg = FALSE;
  121.         
  122.         r = FALSE;
  123.         p = val;
  124.         while(*p)
  125.         {
  126.             if(*p == '\"' || *p == '\'' || *p == ' ')
  127.             {
  128.                 b_chkflg = TRUE; break;
  129.             }
  130.             p++;
  131.         }
  132.         
  133.         if(b_chkflg)
  134.         {
  135.             char *buf = malloc(strlen(val) + 3);
  136.             strcpy(buf, "\"");
  137.             strcat(buf, val);
  138.             strcat(buf, "\"");
  139.             if(WritePrivateProfileString(key, entry, buf, g_inifile))
  140.                 r = TRUE;
  141.             free(buf);
  142.         }
  143.         else
  144.         {
  145.             if(WritePrivateProfileString(key, entry, val, g_inifile))
  146.                 r = TRUE;
  147.         }
  148.     }
  149.     else
  150.     {
  151.         r = FALSE;
  152.         if(RegCreateKey(HKEY_CURRENT_USER, key, &hkey) == 0)
  153.         {
  154.             if(RegSetValueEx(hkey, entry, 0, REG_SZ,
  155.                 (CONST BYTE*)val, strlen(val)) == 0)
  156.             {
  157.                 r = TRUE;
  158.             }
  159.             RegCloseKey(hkey);
  160.         }
  161.     }
  162.     return r;
  163. }
  164.  
  165. /*------------------------------------------------
  166.   get DWORD value from TClock setting
  167. --------------------------------------------------*/
  168. LONG GetMyRegLong(const char *section, const char *entry, LONG defval)
  169. {
  170.     char key[80];
  171.     HKEY hkey;
  172.     DWORD regtype;
  173.     DWORD size;
  174.     BOOL b;
  175.     LONG r;
  176.     
  177.     if(g_bIniSetting) key[0] = 0;
  178.     else strcpy(key, m_mykey);
  179.     
  180.     if(section && *section)
  181.     {
  182.         if(!g_bIniSetting) strcat(key, "\\");
  183.         strcat(key, section);
  184.     }
  185.     else
  186.     {
  187.         if(g_bIniSetting) strcpy(key, "Main");
  188.     }
  189.     
  190.     if(g_bIniSetting)
  191.     {
  192.         r = GetPrivateProfileInt(key, entry, defval, g_inifile);
  193.     }
  194.     else
  195.     {
  196.         b = FALSE;
  197.         if(RegOpenKey(HKEY_CURRENT_USER, key, &hkey) == 0)
  198.         {
  199.             size = 4;
  200.             if(RegQueryValueEx(hkey, entry, 0, ®type,
  201.                 (LPBYTE)&r, &size) == 0)
  202.             {
  203.                 if(size == 4) b = TRUE;
  204.             }
  205.             RegCloseKey(hkey);
  206.         }
  207.         if(b == FALSE) r = defval;
  208.     }
  209.     return r;
  210. }
  211.  
  212. /*-------------------------------------------
  213.   write DWORD value to TClock setting
  214. ---------------------------------------------*/
  215. BOOL SetMyRegLong(const char *section, const char *entry, DWORD val)
  216. {
  217.     HKEY hkey;
  218.     BOOL r;
  219.     char key[80];
  220.     
  221.     if(g_bIniSetting) key[0] = 0;
  222.     else strcpy(key, m_mykey);
  223.     
  224.     if(section && *section)
  225.     {
  226.         if(!g_bIniSetting) strcat(key, "\\");
  227.         strcat(key, section);
  228.     }
  229.     else
  230.     {
  231.         if(g_bIniSetting) strcpy(key, "Main");
  232.     }
  233.     
  234.     if(g_bIniSetting)
  235.     {
  236.         char s[20];
  237.         wsprintf(s, "%d", val);
  238.         r = FALSE;
  239.         if(WritePrivateProfileString(key, entry, s, g_inifile))
  240.             r = TRUE;
  241.     }
  242.     else
  243.     {
  244.         r = FALSE;
  245.         if(RegCreateKey(HKEY_CURRENT_USER, key, &hkey) == 0)
  246.         {
  247.             if(RegSetValueEx(hkey, entry, 0, REG_DWORD,
  248.                 (CONST BYTE*)&val, 4) == 0)
  249.             {
  250.                 r = TRUE;
  251.             }
  252.             RegCloseKey(hkey);
  253.         }
  254.     }
  255.     return r;
  256. }
  257.  
  258. /*-------------------------------------------
  259.   delete a name=value from TClock setting
  260. ---------------------------------------------*/
  261. BOOL DelMyReg(const char *section, const char *entry)
  262. {
  263.     BOOL r;
  264.     char key[80];
  265.     HKEY hkey;
  266.     
  267.     if(g_bIniSetting) key[0] = 0;
  268.     else strcpy(key, m_mykey);
  269.     
  270.     if(section && *section)
  271.     {
  272.         if(!g_bIniSetting) strcat(key, "\\");
  273.         strcat(key, section);
  274.     }
  275.     else
  276.     {
  277.         if(g_bIniSetting) strcpy(key, "Main");
  278.     }
  279.     
  280.     if(g_bIniSetting)
  281.     {
  282.         r = FALSE;
  283.         if(WritePrivateProfileString(key, entry, NULL, g_inifile))
  284.             r = TRUE;
  285.     }
  286.     else
  287.     {
  288.         r = FALSE;
  289.         if(RegOpenKey(HKEY_CURRENT_USER, key, &hkey) == 0)
  290.         {
  291.             if(RegDeleteValue(hkey, entry) == 0)
  292.                 r = TRUE;
  293.             RegCloseKey(hkey);
  294.         }
  295.     }
  296.     return r;
  297. }
  298.  
  299. /*-------------------------------------------
  300.   delete a section from TClock setting
  301. ---------------------------------------------*/
  302. BOOL DelMyRegKey(const char *section)
  303. {
  304.     BOOL r;
  305.     char key[80];
  306.     
  307.     if(g_bIniSetting) key[0] = 0;
  308.     else strcpy(key, m_mykey);
  309.     
  310.     if(section && *section)
  311.     {
  312.         if(!g_bIniSetting) strcat(key, "\\");
  313.         strcat(key, section);
  314.     }
  315.     else
  316.     {
  317.         if(g_bIniSetting) strcpy(key, "Main");
  318.     }
  319.     
  320.     if(g_bIniSetting)
  321.     {
  322.         r = FALSE;
  323.         if(WritePrivateProfileSection(key, NULL, g_inifile))
  324.             r = TRUE;
  325.     }
  326.     else
  327.     {
  328.         r = FALSE;
  329.         if(RegDeleteKey(HKEY_CURRENT_USER, key) == 0)
  330.             r = TRUE;
  331.     }
  332.     return r;
  333. }
  334.  
  335. /*------------------------------------------------
  336.   get a string from registry
  337. --------------------------------------------------*/
  338. int GetRegStr(HKEY rootkey, const char *subkey, const char *entry,
  339.     char *val, int cbData, const char *defval)
  340. {
  341.     HKEY hkey;
  342.     DWORD regtype;
  343.     DWORD size;
  344.     BOOL b;
  345.     
  346.     b = FALSE;
  347.     if(RegOpenKey(rootkey, subkey, &hkey) == 0)
  348.     {
  349.         size = cbData;
  350.         if(RegQueryValueEx(hkey, entry, 0, ®type,
  351.             (LPBYTE)val, &size) == 0)
  352.         {
  353.             if(size == 0) *val = 0;
  354.             b = TRUE;
  355.         }
  356.         RegCloseKey(hkey);
  357.     }
  358.     if(b == FALSE)
  359.         strcpy(val, defval);
  360.     
  361.     return strlen(val);
  362. }
  363.  
  364. /*------------------------------------------------
  365.   get DWORD value from registry
  366. --------------------------------------------------*/
  367. LONG GetRegLong(HKEY rootkey, const char *subkey, const char* entry,
  368.     LONG defval)
  369. {
  370.     HKEY hkey;
  371.     DWORD regtype;
  372.     DWORD size;
  373.     BOOL b;
  374.     int r;
  375.     
  376.     b = FALSE;
  377.     if(RegOpenKey(rootkey, subkey, &hkey) == 0)
  378.     {
  379.         size = 4;
  380.         if(RegQueryValueEx(hkey, entry, 0, ®type,
  381.             (LPBYTE)&r, &size) == 0)
  382.         {
  383.             if(size == 4) b = TRUE;
  384.         }
  385.         RegCloseKey(hkey);
  386.     }
  387.     if(b == FALSE) r = defval;
  388.     return r;
  389. }
  390.  
  391.